home *** CD-ROM | disk | FTP | other *** search
/ LiquidLibrary 2005 September / LiquidLibrary 2005 Sep - Disc 1.iso / pc / Portfolio Browser / Filters / PDF / LIB / pdf_base.ps < prev    next >
Text File  |  2003-01-03  |  21KB  |  630 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is licensed to a single customer by Artifex Software Inc.
  4. % under the terms of a specific OEM agreement.
  5.  
  6. % $RCSfile$ $Revision$
  7. % pdf_base.ps
  8. % Basic parser for PDF reader.
  9.  
  10. % This handles basic parsing of the file (including the trailer
  11. % and cross-reference table), as well as objects, object references,
  12. % streams, and name/number trees; it doesn't include any facilities for
  13. % making marks on the page.
  14.  
  15. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  16. .currentglobal true .setglobal
  17. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  18. pdfdict begin
  19.  
  20. % Define the name interpretation dictionary for reading values.
  21. /valueopdict mark
  22.   (<<) cvn { mark } bind    % don't push an actual mark!
  23.   (>>) cvn /.dicttomark load
  24.   ([) cvn { mark } bind        % ditto
  25.   (]) cvn dup load
  26. %  /true true        % see .pdfexectoken below
  27. %  /false false        % ibid.
  28. %  /null null        % ibid.
  29.   /F dup cvx        % see Objects section below
  30.   /R dup cvx        % see Objects section below
  31.   /stream dup cvx    % see Streams section below
  32. .dicttomark readonly def
  33.  
  34. % ------ Utilities ------ %
  35.  
  36. % Define a scratch string.  The PDF language definition says that
  37. % no line in a PDF file can exceed 255 characters.
  38. /pdfstring 255 string def
  39.  
  40. % Read the previous line of a file.  If we aren't at a line boundary,
  41. % read the line containing the current position.
  42. % Skip any blank lines.
  43. /prevline        % - prevline <startpos> <substring>
  44.  { PDFfile fileposition dup () pdfstring
  45.    2 index 257 sub 0 .max PDFfile exch setfileposition
  46.     {        % Stack: initpos linepos line string
  47.       PDFfile fileposition
  48.       PDFfile 2 index readline pop
  49.       dup length 0 gt
  50.        { 3 2 roll 5 -2 roll pop pop 2 index }
  51.        { pop }
  52.       ifelse
  53.         % Stack: initpos linepos line string startpos
  54.       PDFfile fileposition 5 index ge { exit } if
  55.       pop
  56.     }
  57.    loop pop pop 3 -1 roll pop
  58.  } bind def
  59.  
  60. % Handle the PDF 1.2 #nn escape convention when reading from a file.
  61. % This should eventually be done in C.
  62. /.pdffixname {            % <execname> .pdffixname <execname'>
  63.   PDFversion 1.2 ge {
  64.     dup .namestring (#) search {
  65.       name#escape cvn exch pop
  66.     } {
  67.       pop
  68.     } ifelse
  69.   } if
  70. } bind def
  71. /name#escape            % <post> <(#)> <pre> name#escape <string>
  72. { exch pop
  73.   1 index 2 () /SubFileDecode filter dup (x) readhexstring
  74.         % Stack: post pre stream char t/f
  75.   not { /.pdftoken cvx /syntaxerror signalerror } if
  76.   exch closefile concatstrings
  77.   exch 2 1 index length 2 sub getinterval
  78.   (#) search { name#escape } if concatstrings
  79. } bind def
  80.  
  81. % Execute a file, interpreting its executable names in a given
  82. % dictionary.  The name procedures may do whatever they want
  83. % to the operand stack.
  84. /.pdftokenerror {        % <count> <opdict> <errtoken> .pdftokenerror -
  85.   BXlevel 0 le {
  86.     (%stderr) (w) file
  87.     dup (****************Unknown operator: ) writestring
  88.     dup 2 index .writecvs dup (\n) writestring flushfile
  89.   } if pop pop
  90.   count exch sub { pop } repeat    % pop all the operands
  91. } bind def
  92. /.pdfexectoken {        % <count> <opdict> <exectoken> .pdfexectoken ?
  93.   DEBUG { dup == flush } if
  94.   2 copy .knownget {
  95.     exch pop exch pop exch pop exec
  96.   } {
  97.         % Normally, true, false, and null would appear in opdict
  98.         % and be treated as "operators".  However, there is a
  99.         % special fast case in the PostScript interpreter for names
  100.         % that are defined in, and only in, systemdict and/or
  101.         % userdict: putting these three names in the PDF dictionaries
  102.         % destroys this property for them, slowing down their
  103.         % interpretation in all PostScript code.  Therefore, we
  104.         % check for them explicitly here instead.
  105.     dup dup dup /true eq exch /false eq or exch /null eq or {
  106.       exch pop exch pop //systemdict exch get
  107.     } {
  108.       .pdftokenerror
  109.     } ifelse
  110.   } ifelse
  111. } bind def
  112. /.pdfrun {            % <file> <opdict> .pdfrun -
  113.     % Construct a procedure with the stack depth, file and opdict
  114.     % bound into it.
  115.   1 index cvlit count 2 sub 3 1 roll mark mark 5 2 roll
  116.   {    % Stack: ..operands.. count opdict file
  117.     token {
  118.       dup type /nametype eq {
  119.     dup xcheck {
  120.       .pdfexectoken
  121.     } {
  122.       .pdffixname
  123.       exch pop exch pop DEBUG { dup ==only ( ) print flush } if
  124.     } ifelse
  125.       } {
  126.     exch pop exch pop DEBUG { dup ==only ( ) print flush } if
  127.       } ifelse
  128.     } {
  129.       (%%EOF) cvn cvx .pdfexectoken
  130.     } ifelse
  131.   }
  132.   aload pop .packtomark cvx
  133.   /loop cvx 2 packedarray cvx
  134.   { stopped /PDFsource } aload pop
  135.   PDFsource
  136.   { store { stop } if } aload pop .packtomark cvx
  137.   /PDFsource 3 -1 roll store exec
  138. } bind def
  139.  
  140. % Execute a file, like .pdfrun, for a marking context.
  141. % This temporarily rebinds LocalResources and DefaultMatrix.
  142. /.pdfruncontext {        % <resdict> <file> <opdict> .pdfruncontext -
  143.   /.pdfrun load LocalResources DefaultMatrix
  144.   /LocalResources 7 -1 roll store
  145.   /DefaultMatrix matrix currentmatrix store
  146.   3 .execn
  147.   /DefaultMatrix exch store
  148.   /LocalResources exch store
  149. } bind def
  150.  
  151. % Get the depth of the PDF operand stack.  The main program (pdf_main.ps)
  152. % sets pdfemptycount before calling .pdfrun.
  153. /.pdfcount {        % - .pdfcount <count>
  154.   count pdfemptycount sub
  155. } bind def
  156.  
  157. % ------ File reading ------ %
  158.  
  159. % Read the cross-reference entry for an (unresolved) object.
  160. % The caller must save and restore the PDFfile position if desired.
  161. % For invalid (free) objects, we return 0.
  162. /readxrefentry        % <object#> readxrefentry <objpos>
  163.  { dup Objects exch lget
  164.    PDFfile exch setfileposition
  165.    PDFfile token pop        % object position
  166.    PDFfile token pop        % generation #
  167.    PDFfile token pop        % n or f
  168.    dup /n eq
  169.     { pop 1 add dup 255 gt
  170.        { Generations ltype /stringtype eq
  171.       {        % Convert Generations from a string to an array.
  172.         larray Generations llength lgrowto dup
  173.         0 1 2 index llength 1 sub
  174.          { Generations 1 index lget lput dup
  175.          }
  176.         for pop /Generations exch store
  177.       }
  178.      if
  179.        }
  180.       if
  181.     }
  182.     { /f eq
  183.        { pop 0 }
  184.        { /readxrefentry cvx /syntaxerror signalerror }
  185.       ifelse
  186.     }
  187.    ifelse
  188.         % Stack: obj# objpos 1+gen#
  189.    Generations 4 -1 roll 3 -1 roll lput
  190.  } bind def
  191.  
  192. % ================================ Objects ================================ %
  193.  
  194. % Since we may have more than 64K objects, we have to use a 2-D array to
  195. % hold them (and the parallel Generations structure).
  196. /lshift 9 def
  197. /lnshift lshift neg def
  198. /lsubmask 1 lshift bitshift 1 sub def
  199. /lsublen lsubmask 1 add def
  200. /larray {    % - larray <larray>
  201.   [ [] ]
  202. } bind def
  203. /lstring {    % - lstring <lstring>
  204.   [ () ]
  205. } bind def
  206. /ltype {    % <lseq> type <type>
  207.   0 get type
  208. } bind def
  209. /lget {        % <lseq> <index> lget <value>
  210.   dup //lsubmask and 3 1 roll //lnshift bitshift get exch get
  211. } bind def
  212. /lput {        % <lseq> <index> <value> lput -
  213.   3 1 roll
  214.   dup //lsubmask and 4 1 roll //lnshift bitshift get
  215.   3 1 roll put
  216. } bind def
  217. /llength {    % <lseq> llength <length>
  218.   dup length 1 sub dup //lshift bitshift
  219.   3 1 roll get length add
  220. } bind def
  221. % lgrowto assumes newlength > llength(lseq)
  222. /growto {    % <string/array> <length> growto <string'/array'>
  223.   1 index type /stringtype eq { string } { array } ifelse
  224.   2 copy copy pop exch pop
  225. } bind def
  226. /lgrowto {    % <lseq> <newlength> lgrowto <lseq'>
  227.     dup //lsubmask add //lnshift bitshift dup 3 index length gt {
  228.     % Add more sub-arrays.  Start by completing the last existing one.
  229.         % Stack: lseq newlen newtoplen
  230.     3 -1 roll dup llength 1 sub //lsubmask or 1 add lgrowto
  231.         % Stack: newlen newtoplen lseq
  232.     [ exch aload pop
  233.     counttomark 2 add -1 roll        % newtoplen
  234.     counttomark sub { dup 0 0 getinterval lsublen growto } repeat
  235.     dup 0 0 getinterval ] exch
  236.   } {
  237.     pop
  238.   } ifelse
  239.     % Expand the last sub-array.
  240.   1 sub //lsubmask and 1 add
  241.   exch dup dup length 1 sub 2 copy
  242.         % Stack: newsublen lseq lseq len-1 lseq len-1
  243.   get 5 -1 roll growto put
  244. } bind def
  245. /lforall {    % <lseq> <proc> lforall -
  246.   /forall cvx 2 packedarray cvx forall
  247. } bind def
  248.  
  249. % We keep track of PDF objects using the following PostScript variables:
  250. %
  251. %    Generations (lstring): Generations[N] holds 1+ the current
  252. %        generation number for object number N.  (As far as we can tell,
  253. %        this is needed only for error checking.)  For free objects,
  254. %        Generations[N] is 0.
  255. %
  256. %    Objects (larray): If object N is loaded, Objects[N] is the actual
  257. %        object; otherwise, Objects[N] is an executable integer giving
  258. %        the file offset of the object's entry in the cross-reference
  259. %        table.
  260. %
  261. %    GlobalObjects (dictionary): If object N has been resolved in
  262. %        global VM, GlobalObjects[N] is the same as Objects[N]
  263. %        (except that GlobalObjects itself is stored in global VM,
  264. %        so the entry will not be deleted at the end of the page).
  265. %
  266. %    IsGlobal (lstring): IsGlobal[N] = 1 iff object N was resolved in
  267. %        global VM.  This is an accelerator to avoid having to do a
  268. %        dictionary lookup in GlobalObjects when resolving every object.
  269.  
  270. % Initialize the PDF object tables.
  271. /initPDFobjects {        % - initPDFobjects -
  272.   /Objects larray def
  273.   /Generations lstring def
  274.   .currentglobal true .setglobal
  275.   /GlobalObjects 20 dict def
  276.   .setglobal
  277.   /IsGlobal lstring def
  278. } bind def
  279.  
  280. % Grow the tables to a specified size.
  281. /growPDFobjects {        % <minsize> growPDFobjects -
  282.   dup Objects llength gt {
  283.     dup Objects exch lgrowto /Objects exch def
  284.   } if
  285.   dup Generations llength gt {
  286.     dup Generations exch lgrowto /Generations exch def
  287.   } if
  288.   dup IsGlobal llength gt {
  289.     dup IsGlobal exch lgrowto /IsGlobal exch def
  290.   } if
  291.   pop
  292. } bind def
  293.  
  294. % We represent an unresolved object reference by a procedure of the form
  295. % {obj# gen# resolveR}.  This is not a possible PDF object, because PDF has
  296. % no way to represent procedures.  Since PDF in fact has no way to represent
  297. % any PostScript object that doesn't evaluate to itself, we can 'force'
  298. % a possibly indirect object painlessly with 'exec'.
  299. % Note that since we represent streams by executable dictionaries
  300. % (see below), we need both an xcheck and a type check to determine
  301. % whether an object has been resolved.
  302. /resolved? {        % <object#> resolved? <value> true
  303.             % <object#> resolved? false
  304.   Objects 1 index lget dup xcheck {
  305.     dup type /integertype eq {
  306.         % Check whether the object is in GlobalObjects.
  307.       pop IsGlobal 1 index lget 0 eq {
  308.     pop false
  309.       } {
  310.         % Update Objects from GlobalObjects
  311.     DEBUG { (%Global=>local: ) print dup == } if
  312.     GlobalObjects 1 index get dup Objects 4 1 roll lput true
  313.       } ifelse
  314.     } {
  315.       exch pop true
  316.     } ifelse
  317.   } {
  318.     exch pop true
  319.   } ifelse
  320. } bind def
  321. /oforce /exec load def
  322. /oget {        % <array> <index> oget <object>
  323.         % <dict> <key> oget <object>
  324.         % Before release 6.20, this procedure stored the resolved
  325.         % object back into the referring slot.  In order to support
  326.         % PDF linearization, we no longer do this.
  327.   get oforce
  328. } bind def
  329. % A null value in a dictionary is equivalent to an omitted key;
  330. % we must check for this specially.
  331. /knownoget {    % <dict> <key> knownoget <value> true
  332.         % <dict> <key> knownoget false
  333.         % See oget above regarding this procedure.
  334.   .knownget {
  335.     oforce dup null eq { pop false } { true } ifelse
  336.   } {
  337.     false
  338.   } ifelse
  339. } bind def
  340.  
  341. % PDF 1.1 defines a 'foreign file reference', but not its meaning.
  342. % Per the specification, we convert these to nulls.
  343. /F {        % <file#> <object#> <generation#> F <object>
  344.         % Some PDF 1.1 files use F as a synonym for f!
  345.    .pdfcount 3 lt { f } { pop pop pop null } ifelse
  346. } bind def
  347.  
  348. /checkgeneration {  % <object#> <generation#> checkgeneration <object#> <OK>
  349.   Generations 2 index lget 1 sub 1 index eq {
  350.     pop true
  351.   } {
  352.     QUIET not {
  353.       Generations 2 index lget 0 eq {
  354.     (Warning: reference to free object: )
  355.       } {
  356.     (Warning: wrong generation: )
  357.       } ifelse print 1 index =only ( ) print =only ( R) =
  358.     } {
  359.       pop
  360.     } ifelse false
  361.   } ifelse
  362. } bind def
  363. /R {        % <object#> <generation#> R <object>
  364.   /resolveR cvx 3 packedarray cvx
  365. } bind def
  366.  
  367. % If we encounter an object definition while reading sequentially,
  368. % we just store it away and keep going.
  369. /objopdict mark
  370.   valueopdict { } forall
  371.   /endobj dup cvx
  372. .dicttomark readonly def
  373. /obj {            % <object#> <generation#> obj <object>
  374.   PDFfile objopdict .pdfrun
  375. } bind def
  376. /endobj {        % <object#> <generation#> <object> endobj <object>
  377.   3 1 roll
  378.         % Read the xref entry if we haven't yet done so.
  379.         % This is only needed for generation # checking.
  380.   1 index resolved? {
  381.     pop
  382.   } {
  383.     PDFfile fileposition
  384.     2 index readxrefentry pop
  385.     PDFoffset add PDFfile exch setfileposition
  386.   } ifelse
  387.   checkgeneration {
  388.         % The only global objects we bother to save are
  389.         % (resource) dictionaries.
  390.     1 index dup gcheck exch type /dicttype eq and {
  391.       DEBUG { (%Local=>global: ) print dup == } if
  392.       GlobalObjects 1 index 3 index put
  393.       IsGlobal 1 index 1 put
  394.     } if
  395.     Objects exch 2 index lput
  396.   } {
  397.     pop pop null
  398.   } ifelse
  399. } bind def
  400.  
  401. % When resolving an object reference, we stop at the endobj.
  402. /resolveopdict mark
  403.   valueopdict { } forall
  404.   /endobj { endobj exit } bind
  405.                 % OmniForm generates PDF file with endobj missing in some
  406.                 % objects. AR ignores this. So we have to do it too.
  407.   /obj { pop pop endobj exit } bind
  408. .dicttomark readonly def
  409. /resolveR {        % <object#> <generation#> resolveR <object>
  410.   DEBUG { (%Resolving: ) print 2 copy 2 array astore == } if
  411.   1 index resolved? {
  412.     exch pop exch pop
  413.   } {
  414.     PDFfile fileposition 3 1 roll
  415.     1 index readxrefentry
  416.     3 1 roll checkgeneration {
  417.             % Stack: savepos objpos obj#
  418.      exch PDFoffset add PDFfile exch setfileposition
  419.      PDFfile token pop 2 copy ne
  420.       { (xref error!) = /resolveR cvx /rangecheck signalerror
  421.       }
  422.      if pop PDFfile token pop
  423.      PDFfile token pop /obj ne
  424.       { (xref error!) = /resolveR cvx /rangecheck signalerror
  425.       }
  426.      if
  427.      pdf_run_resolve    % PDFfile resolveopdict .pdfrun
  428.     }
  429.     {        % Don't cache if the generation # is wrong.
  430.      pop pop null
  431.     } ifelse
  432.     exch PDFfile exch setfileposition
  433.   } ifelse
  434. } bind def      
  435.  
  436. % ================================ Streams ================================ %
  437.  
  438. % We represent a stream by an executable dictionary that contains,
  439. % in addition to the contents of the original stream dictionary:
  440. %    /File - the file or string where the stream contents are stored,
  441. %      if the stream is not an external one.
  442. %    /FilePosition - iff File is a file, the position in the file
  443. %      where the contents start.
  444. %    /StreamKey - the key used to decrypt this stream, if any.
  445. % We do the real work of constructing the data stream only when the
  446. % contents are needed.
  447.  
  448. % Construct a stream.  The length is not reliable in the face of
  449. % different end-of-line conventions, but it's all we've got.
  450. %
  451. % PDF files are inconsistent about what may fall between the 'stream' keyword
  452. % and the actual stream data, and it appears that no one algorithm can
  453. % detect this reliably.  We used to try to guess whether the file included
  454. % extraneous \r and/or \n characters, but we no longer attempt to do so,
  455. % especially since the PDF 1.2 specification states flatly that the only
  456. % legal terminators following the 'stream' keyword are \n or \r\n, both of
  457. % which are properly skipped and discarded by the token operator.
  458. /stream {    % <dict> stream <modified_dict>
  459.   dup /F known dup PDFsource PDFfile eq or {
  460.     not {
  461.       dup /File PDFfile put
  462.       dup /FilePosition PDFfile fileposition put
  463.       DEBUG { (%FilePosition: ) print dup /FilePosition get == } if
  464.     } if
  465.     PDFfile fileposition 1 index /Length oget add
  466.       PDFfile exch setfileposition
  467.   } {
  468.     pop
  469.     % We're already reading from a stream, which we can't reposition.
  470.     % Capture the sub-stream contents in a string.
  471.     dup /Length oget string PDFsource exch readstring
  472.     not {
  473.       (Unexpected EOF in stream!) =
  474.       /stream cvx /rangecheck signalerror
  475.     } if
  476.     1 index exch /File exch put
  477.   } ifelse
  478.   PDFsource token pop
  479.     /endstream ne { /stream cvx /syntaxerror signalerror } if
  480.   cvx
  481. } bind def
  482. /endstream {
  483.   exit
  484. } bind def
  485.  
  486. % Contrary to the published PDF (1.3) specification, Acrobat Reader
  487. % accepts abbreviated filter names everywhere, not just for in-line images,
  488. % and some applications (notably htmldoc) rely on this.
  489. /unabbrevfilterdict mark
  490.   /AHx /ASCIIHexDecode  /A85 /ASCII85Decode  /CCF /CCITTFaxDecode
  491.   /DCT /DCTDecode  /Fl /FlateDecode  /LZW /LZWDecode  /RL /RunLengthDecode
  492. .dicttomark readonly def
  493.  
  494. % Extract and apply filters.
  495. /filterparms {        % <dict> <DPkey> <Fkey> filterparms
  496.             %   <dict> <parms> <filternames>
  497.   2 index exch .knownget {
  498.     exch 2 index exch .knownget {
  499.         % Both filters and parameters.
  500.       exch dup type /nametype eq {
  501.     1 array astore exch 1 array astore exch
  502.       } if
  503.     } {
  504.         % Filters, but no parameters.
  505.       null exch
  506.       dup type /nametype eq { 1 array astore } if
  507.     } ifelse
  508.   } {
  509.         % No filters: ignore parameters, if any.
  510.     pop null { }
  511.   } ifelse
  512. } bind def
  513. /filtername {        % <filtername> filtername <filtername'>
  514.   //unabbrevfilterdict 1 index .knownget { exch pop } if
  515. } bind def
  516. /applyfilters {        % <parms> <source> <filternames> applyfilters <stream>
  517.   2 index null eq {
  518.     { filtername filter }
  519.   } {
  520.     {        % Stack: parms stream filtername
  521.       2 index 0 oget dup null eq { pop } { exch } ifelse filtername filter
  522.       exch dup length 1 sub 1 exch getinterval exch
  523.     }
  524.   } ifelse forall exch pop
  525. } bind def
  526.  
  527. % Resolve a stream dictionary to a PostScript stream.
  528. % Streams with no filters require special handling:
  529. %    - If we are going to interpret their contents, we let endstream
  530. %      terminate the interpretation loop;
  531. %    - If we are just going to read data from them, we impose
  532. %      a SubFileDecode filter that reads just the requisite amount of data.
  533. % Note that, in general, resolving a stream repositions PDFfile.
  534. % Clients must save and restore the position of PDFfile themselves.
  535. /resolvestream {    % <streamdict> <readdata?> resolvestream <stream>
  536.   1 index /F .knownget {
  537.         % This stream is stored on an external file.
  538.     (r) file 3 -1 roll
  539.     /FDecodeParms /FFilter filterparms
  540.         % Stack: readdata? file dict parms filternames
  541.     4 -1 roll exch
  542.     pdf_decrypt_stream
  543.     applyfilters
  544.   } {
  545.     exch dup /FilePosition .knownget {
  546.       1 index /File get exch setfileposition
  547.     } if
  548.         % Stack: readdata? dict
  549.     /DecodeParms /Filter filterparms
  550.         % Stack: readdata? dict parms filternames
  551.     2 index /File get exch
  552.         % Stack: readdata? dict parms file/string filternames
  553.     pdf_decrypt_stream        % add decryption if needed
  554.     dup length 0 eq {
  555.         % All the PDF filters have EOD markers, but in this case
  556.         % there is no specified filter.
  557.       pop exch pop
  558.         % Stack: readdata? dict file/string
  559.       2 index {
  560.         % We're going to read data; use a SubFileDecode filter.
  561.     1 index /Length oget () /SubFileDecode filter
  562.       } {
  563.     dup type /filetype ne {
  564.         % Use a SubFileDecode filter to read from a string.
  565.       0 () /SubFileDecode filter
  566.     } if
  567.       } ifelse
  568.     } {
  569.       applyfilters
  570.     } ifelse
  571.   } ifelse
  572.         % Stack: readdata? dict file
  573.   exch pop exch pop
  574. } bind def
  575.  
  576. % ============================ Name/number trees ============================ %
  577.  
  578. /nameoget {        % <nametree> <key> nameoget <obj|null>
  579.   exch /Names exch .treeget
  580. } bind def
  581.  
  582. /numoget {        % <numtree> <key> numoget <obj|null>
  583.   exch /Nums exch .treeget
  584. } bind def
  585.  
  586. /.treeget {        % <key> <leafkey> <tree> .treeget <obj|null>
  587.   dup /Kids knownoget {
  588.     exch pop .branchget
  589.   } {
  590.     exch get .leafget
  591.   } ifelse
  592. } bind def
  593.  
  594. /.branchget {        %  <key> <leafkey> <kids> .branchget <obj|null>
  595.   dup length 0 eq {
  596.     pop pop pop null
  597.   } {
  598.     dup length -1 bitshift 2 copy oget
  599.             % Stack: key leafkey kids mid kids[mid]
  600.     dup /Limits oget aload pop
  601.             % Stack: key leafkey kids mid kids[mid] min max
  602.     6 index lt {
  603.       pop pop
  604.       1 add 1 index length 1 index sub getinterval .branchget
  605.     } {
  606.       5 index gt {
  607.     pop
  608.     0 exch getinterval .branchget
  609.       } {
  610.     exch pop exch pop .treeget
  611.       } ifelse
  612.     } ifelse
  613.   } ifelse
  614. } bind def
  615.  
  616. /.leafget {        % <key> <pairs> .leafget <obj|null>
  617.   dup length 2 eq {
  618.     dup 0 get 2 index eq { 1 oget } { pop null } ifelse
  619.     exch pop
  620.   } {
  621.     dup length -1 bitshift -2 and 2 copy oget
  622.             % Stack: key pairs mid pairs[mid]
  623.     3 index gt { 0 exch } { 1 index length 1 index sub } ifelse
  624.     getinterval .leafget
  625.   } ifelse
  626. } bind def
  627.  
  628. end            % pdfdict
  629. .setglobal
  630.